The final section of the workshop deck moves beyond prompting and single-agent sessions. It explains MCP as the bridge between the model and external systems, codifies context hygiene as a daily engineering habit, and shows where AI fits across the SDLC without defaulting to the heaviest orchestration pattern every time.
The deck describes MCP as the open standard that lets models call tools and data sources as built-in capabilities. The key architectural point is that tool results come back into the context window, where the agent can reason over them in the next step.
Instead of only returning prose, the agent can ask for a GitHub query, a database lookup, a file read, or another supported MCP action.
The MCP server handles the real-world operation and returns structured results rather than forcing the user to copy context in manually.
The next model turn can inspect that output, decide what it means, and choose the next action. That loop is what makes tool use agentic instead of decorative.
Issues, PRs, commits, and branch context become directly accessible instead of being summarized second-hand by a developer.
Postgres, SQLite, and other stores can be queried directly when the workflow permits it, turning runtime data into usable context.
Controlled read and write access lets the agent inspect local assets, generated files, and project structure without extra glue code.
Useful for docs and reference material mid-task, with the same warning as always: irrelevant results still consume budget.
Ticket context, status, and workflow details can flow into the coding session without developers translating everything by hand.
Thread context and posted summaries can become part of the execution loop when communication itself is part of the task.
Start MCP adoption with one or two high-signal, mostly read-heavy tools. GitHub, docs, or a safe data source usually create leverage faster than wiring every possible system into the agent on day one.
The workshop calls this out directly: garbage context in, garbage answers out. Better results come from repeated session hygiene, not from hoping the model will sort through noise on its own.
Use CLAUDE.md and skill files so the model gets stable instructions without repeating the same walls of text in every prompt.
Claude Code’s /compact exists because older history keeps shaping future answers. Summarize before starting the next subtask.
Five focused files beat twenty noisy ones. The workshop treats file selection as part of prompt engineering, not a separate concern.
The model needs the key lines and stack traces, not an unfiltered dump. Distilled failure context is cheaper and easier to reason about.
Task A can poison Task B if the model keeps dragging old assumptions forward. New summary or new session is often the cleaner choice.
Generated code, lock files, and irrelevant artifacts should be excluded so the model does not waste attention on noise the team never intended to discuss.
Chat history is usually the biggest controllable variable. A compacted summary replaces a growing transcript; the model keeps the substance without the dead-end turns that shaped earlier answers.
One of the more useful slides reframes AI coding as an SDLC capability. Define, design, build, test, and deploy can all use agentic assistance if the outputs are governed and evaluated instead of trusted by default.
Meeting transcripts, RAID logs, and edge-case mining can all start earlier when the model helps structure ambiguous input.
System outlines, API specs, threat-model starters, and early UI concepts become faster to draft and easier to compare.
Agents help create code, generate tests, and review pull requests, especially when paired with the right model and autonomy level.
Large test suites, synthetic edge cases, and failure-pattern analysis all benefit from the same prompting and orchestration patterns.
Non-interactive sessions such as claude -p make release notes, user guides, and ops-oriented automation viable parts of the pipeline.
The slide’s most important sentence is the guardrail: every AI-generated output still needs an evaluation threshold before it counts as done. Speed without acceptance criteria is just faster error production.
The deck closes with a practical matrix: pick the tool, model, and orchestration pattern that fits the job instead of reaching for the most autonomous option by default.
Use Copilot with autocomplete or lightweight chat support. Do not start an orchestration workflow for trivial boilerplate.
Either tool works well here. The deck prefers a fast, cheap model such as Sonnet 4.6 for general Q&A and understanding work.
Copilot Edit or a tightly scoped agent session is enough. The key is explicit scope and a clear reference pattern.
Claude Code with Sonnet 4.6 and plan mode is the workshop’s default pattern for real development work that crosses boundaries.
Step up to Opus 4.6, subagents, or agent teams only when the coordination and reasoning load justify the extra cost.
Use non-interactive runs such as claude -p or async issue assignment through Copilot Coding Agent when the work is well-bounded and review happens on the output artifact.
Section takeaway: the workshop is arguing for AI-native engineering habits, not indiscriminate autonomy. Use MCP when outside context matters, keep sessions clean, and scale from single-agent to multi-agent only when the task genuinely needs it.